//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Chime service.
///
///   Most of these APIs are no longer supported and will not be updated. We recommend using the latest versions in the  Amazon Chime SDK API reference, in the Amazon Chime SDK. Using the latest versions requires migrating to dedicated namespaces. For more information, refer to   Migrating from the Amazon Chime namespace in the  Amazon Chime SDK Developer Guide.  The Amazon Chime application programming interface (API) is designed so administrators can perform key tasks, such as creating and managing Amazon Chime accounts, users, and Voice Connectors. This guide provides detailed information about the Amazon Chime API, including operations, types, inputs and outputs, and error codes. You can use an AWS SDK, the AWS Command Line Interface (AWS CLI), or the REST API to make API calls for Amazon Chime. We recommend using an AWS SDK or the  AWS CLI. The page for each API action contains a See Also section that includes links to information about using the action with a language-specific  AWS SDK or the AWS CLI.  Using an AWS SDK   You don't need to write code to calculate a signature for request authentication. The SDK clients authenticate your requests by using access keys that you provide. For more information about AWS SDKs, see the  AWS Developer Center.   Using the AWS CLI  Use your access keys with the AWS CLI to make API calls. For information about setting up the AWS CLI, see  Installing the AWS Command Line Interface in the AWS Command Line Interface User Guide. For a list of available Amazon Chime commands, see the  Amazon Chime commands in the  AWS CLI Command Reference.   Using REST APIs  If you use REST to make API calls, you must authenticate your request by providing a signature. Amazon Chime supports Signature Version 4. For more information, see  Signature Version 4 Signing Process in the Amazon Web Services General Reference. When making REST API calls, use the service name chime and REST endpoint https://service.chime.aws.amazon.com.   Administrative permissions are controlled using AWS Identity and Access Management (IAM). For more information, see  Identity and Access Management for Amazon Chime in the Amazon Chime Administration Guide.
public struct Chime: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Chime client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: nil,
            partition: partition,
            serviceName: "Chime",
            serviceIdentifier: "chime",
            serviceProtocol: .restjson,
            apiVersion: "2018-05-01",
            endpoint: endpoint,
            serviceEndpoints: Self.serviceEndpoints,
            partitionEndpoints: Self.partitionEndpoints,
            errorType: ChimeErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }


    /// custom endpoints for regions
    static var serviceEndpoints: [String: String] {[
        "aws-global": "chime.us-east-1.amazonaws.com"
    ]}

    /// Default endpoint and region to use for each partition
    static var partitionEndpoints: [AWSPartition: (endpoint: String, region: SotoCore.Region)] {[
        .aws: (endpoint: "aws-global", region: .useast1)
    ]}


    // MARK: API Calls

    /// Associates a phone number with the specified Amazon Chime user.
    @Sendable
    @inlinable
    public func associatePhoneNumberWithUser(_ input: AssociatePhoneNumberWithUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociatePhoneNumberWithUserResponse {
        try await self.client.execute(
            operation: "AssociatePhoneNumberWithUser", 
            path: "/accounts/{AccountId}/users/{UserId}?operation=associate-phone-number", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a phone number with the specified Amazon Chime user.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - e164PhoneNumber: The phone number, in E.164 format.
    ///   - userId: The user ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func associatePhoneNumberWithUser(
        accountId: String,
        e164PhoneNumber: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociatePhoneNumberWithUserResponse {
        let input = AssociatePhoneNumberWithUserRequest(
            accountId: accountId, 
            e164PhoneNumber: e164PhoneNumber, 
            userId: userId
        )
        return try await self.associatePhoneNumberWithUser(input, logger: logger)
    }

    /// Associates the specified sign-in delegate groups with the specified Amazon Chime account.
    @Sendable
    @inlinable
    public func associateSigninDelegateGroupsWithAccount(_ input: AssociateSigninDelegateGroupsWithAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateSigninDelegateGroupsWithAccountResponse {
        try await self.client.execute(
            operation: "AssociateSigninDelegateGroupsWithAccount", 
            path: "/accounts/{AccountId}?operation=associate-signin-delegate-groups", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates the specified sign-in delegate groups with the specified Amazon Chime account.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - signinDelegateGroups: The sign-in delegate groups.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateSigninDelegateGroupsWithAccount(
        accountId: String,
        signinDelegateGroups: [SigninDelegateGroup],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateSigninDelegateGroupsWithAccountResponse {
        let input = AssociateSigninDelegateGroupsWithAccountRequest(
            accountId: accountId, 
            signinDelegateGroups: signinDelegateGroups
        )
        return try await self.associateSigninDelegateGroupsWithAccount(input, logger: logger)
    }

    /// Adds up to 50 members to a chat room in an Amazon Chime Enterprise account. Members can be users or bots. The member role designates whether the member is a  chat room administrator or a general chat room member.
    @Sendable
    @inlinable
    public func batchCreateRoomMembership(_ input: BatchCreateRoomMembershipRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchCreateRoomMembershipResponse {
        try await self.client.execute(
            operation: "BatchCreateRoomMembership", 
            path: "/accounts/{AccountId}/rooms/{RoomId}/memberships?operation=batch-create", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds up to 50 members to a chat room in an Amazon Chime Enterprise account. Members can be users or bots. The member role designates whether the member is a  chat room administrator or a general chat room member.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - membershipItemList: The list of membership items.
    ///   - roomId: The room ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchCreateRoomMembership(
        accountId: String,
        membershipItemList: [MembershipItem],
        roomId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchCreateRoomMembershipResponse {
        let input = BatchCreateRoomMembershipRequest(
            accountId: accountId, 
            membershipItemList: membershipItemList, 
            roomId: roomId
        )
        return try await self.batchCreateRoomMembership(input, logger: logger)
    }

    /// Moves phone numbers into the
    /// Deletion queue. Phone numbers must be disassociated from any users or Amazon Chime Voice Connectors before they can be deleted.
    ///
    /// Phone numbers remain in the
    /// Deletion queue for 7 days before they are deleted permanently.
    @Sendable
    @inlinable
    public func batchDeletePhoneNumber(_ input: BatchDeletePhoneNumberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchDeletePhoneNumberResponse {
        try await self.client.execute(
            operation: "BatchDeletePhoneNumber", 
            path: "/phone-numbers?operation=batch-delete", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Moves phone numbers into the
    /// Deletion queue. Phone numbers must be disassociated from any users or Amazon Chime Voice Connectors before they can be deleted.
    ///
    /// Phone numbers remain in the
    /// Deletion queue for 7 days before they are deleted permanently.
    ///
    /// Parameters:
    ///   - phoneNumberIds: List of phone number IDs.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchDeletePhoneNumber(
        phoneNumberIds: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchDeletePhoneNumberResponse {
        let input = BatchDeletePhoneNumberRequest(
            phoneNumberIds: phoneNumberIds
        )
        return try await self.batchDeletePhoneNumber(input, logger: logger)
    }

    /// Suspends up to 50 users from a Team or EnterpriseLWA Amazon Chime account. For more information about different account types, see Managing Your Amazon Chime Accounts in the Amazon Chime Administration Guide. Users suspended from a Team account are disassociated from the account,but they can continue to use Amazon Chime as free users. To remove the suspension from suspended Team account users, invite them to the Team account again. You can use the InviteUsers action to do so. Users suspended from an EnterpriseLWA account are immediately signed out of Amazon Chime and can no longer sign in. To remove the suspension from suspended EnterpriseLWA account users, use the  BatchUnsuspendUser action.
    /// To sign out users without suspending them, use the
    /// LogoutUser action.
    @Sendable
    @inlinable
    public func batchSuspendUser(_ input: BatchSuspendUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchSuspendUserResponse {
        try await self.client.execute(
            operation: "BatchSuspendUser", 
            path: "/accounts/{AccountId}/users?operation=suspend", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Suspends up to 50 users from a Team or EnterpriseLWA Amazon Chime account. For more information about different account types, see Managing Your Amazon Chime Accounts in the Amazon Chime Administration Guide. Users suspended from a Team account are disassociated from the account,but they can continue to use Amazon Chime as free users. To remove the suspension from suspended Team account users, invite them to the Team account again. You can use the InviteUsers action to do so. Users suspended from an EnterpriseLWA account are immediately signed out of Amazon Chime and can no longer sign in. To remove the suspension from suspended EnterpriseLWA account users, use the  BatchUnsuspendUser action.
    /// To sign out users without suspending them, use the
    /// LogoutUser action.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - userIdList: The request containing the user IDs to suspend.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchSuspendUser(
        accountId: String,
        userIdList: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchSuspendUserResponse {
        let input = BatchSuspendUserRequest(
            accountId: accountId, 
            userIdList: userIdList
        )
        return try await self.batchSuspendUser(input, logger: logger)
    }

    /// Removes the suspension from up to 50 previously suspended users for the specified Amazon Chime EnterpriseLWA account. Only users on EnterpriseLWA accounts can be unsuspended using this action. For more information about different account types, see   Managing Your Amazon Chime Accounts in the account types, in the Amazon Chime Administration Guide.
    ///  Previously suspended users who are unsuspended using this action are returned to
    /// Registered
    /// status. Users who are not previously suspended are ignored.
    @Sendable
    @inlinable
    public func batchUnsuspendUser(_ input: BatchUnsuspendUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchUnsuspendUserResponse {
        try await self.client.execute(
            operation: "BatchUnsuspendUser", 
            path: "/accounts/{AccountId}/users?operation=unsuspend", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the suspension from up to 50 previously suspended users for the specified Amazon Chime EnterpriseLWA account. Only users on EnterpriseLWA accounts can be unsuspended using this action. For more information about different account types, see   Managing Your Amazon Chime Accounts in the account types, in the Amazon Chime Administration Guide.
    ///  Previously suspended users who are unsuspended using this action are returned to
    /// Registered
    /// status. Users who are not previously suspended are ignored.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - userIdList: The request containing the user IDs to unsuspend.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchUnsuspendUser(
        accountId: String,
        userIdList: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchUnsuspendUserResponse {
        let input = BatchUnsuspendUserRequest(
            accountId: accountId, 
            userIdList: userIdList
        )
        return try await self.batchUnsuspendUser(input, logger: logger)
    }

    /// Updates phone number product types or calling names. You can update one attribute at a time for each UpdatePhoneNumberRequestItem. For example, you can update the product type or the calling name. For toll-free numbers, you cannot use the Amazon Chime Business Calling product type. For numbers outside the U.S., you must use the Amazon Chime SIP Media Application Dial-In product type. Updates to outbound calling names can take up to 72 hours to complete. Pending updates to outbound calling names must be complete before you can request another update.
    @Sendable
    @inlinable
    public func batchUpdatePhoneNumber(_ input: BatchUpdatePhoneNumberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchUpdatePhoneNumberResponse {
        try await self.client.execute(
            operation: "BatchUpdatePhoneNumber", 
            path: "/phone-numbers?operation=batch-update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates phone number product types or calling names. You can update one attribute at a time for each UpdatePhoneNumberRequestItem. For example, you can update the product type or the calling name. For toll-free numbers, you cannot use the Amazon Chime Business Calling product type. For numbers outside the U.S., you must use the Amazon Chime SIP Media Application Dial-In product type. Updates to outbound calling names can take up to 72 hours to complete. Pending updates to outbound calling names must be complete before you can request another update.
    ///
    /// Parameters:
    ///   - updatePhoneNumberRequestItems: The request containing the phone number IDs and product types or calling names to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchUpdatePhoneNumber(
        updatePhoneNumberRequestItems: [UpdatePhoneNumberRequestItem],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchUpdatePhoneNumberResponse {
        let input = BatchUpdatePhoneNumberRequest(
            updatePhoneNumberRequestItems: updatePhoneNumberRequestItems
        )
        return try await self.batchUpdatePhoneNumber(input, logger: logger)
    }

    /// Updates user details within the UpdateUserRequestItem object for up to 20 users for the specified Amazon Chime account. Currently, only LicenseType updates are supported for this action.
    @Sendable
    @inlinable
    public func batchUpdateUser(_ input: BatchUpdateUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchUpdateUserResponse {
        try await self.client.execute(
            operation: "BatchUpdateUser", 
            path: "/accounts/{AccountId}/users", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates user details within the UpdateUserRequestItem object for up to 20 users for the specified Amazon Chime account. Currently, only LicenseType updates are supported for this action.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - updateUserRequestItems: The request containing the user IDs and details to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchUpdateUser(
        accountId: String,
        updateUserRequestItems: [UpdateUserRequestItem],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchUpdateUserResponse {
        let input = BatchUpdateUserRequest(
            accountId: accountId, 
            updateUserRequestItems: updateUserRequestItems
        )
        return try await self.batchUpdateUser(input, logger: logger)
    }

    /// Creates an Amazon Chime account under the administrator's AWS account. Only Team account types are currently supported for this action. For more information about different account types, see  Managing Your Amazon Chime Accounts in the Amazon Chime  Administration Guide.
    @Sendable
    @inlinable
    public func createAccount(_ input: CreateAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAccountResponse {
        try await self.client.execute(
            operation: "CreateAccount", 
            path: "/accounts", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Chime account under the administrator's AWS account. Only Team account types are currently supported for this action. For more information about different account types, see  Managing Your Amazon Chime Accounts in the Amazon Chime  Administration Guide.
    ///
    /// Parameters:
    ///   - name: The name of the Amazon Chime account.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAccount(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAccountResponse {
        let input = CreateAccountRequest(
            name: name
        )
        return try await self.createAccount(input, logger: logger)
    }

    /// Creates a bot for an Amazon Chime Enterprise account.
    @Sendable
    @inlinable
    public func createBot(_ input: CreateBotRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateBotResponse {
        try await self.client.execute(
            operation: "CreateBot", 
            path: "/accounts/{AccountId}/bots", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a bot for an Amazon Chime Enterprise account.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - displayName: The bot display name.
    ///   - domain: The domain of the Amazon Chime Enterprise account.
    ///   - logger: Logger use during operation
    @inlinable
    public func createBot(
        accountId: String,
        displayName: String,
        domain: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateBotResponse {
        let input = CreateBotRequest(
            accountId: accountId, 
            displayName: displayName, 
            domain: domain
        )
        return try await self.createBot(input, logger: logger)
    }

    /// Uses the join token and call metadata in a meeting request (From number, To number, and so forth) to initiate an outbound call to a public  switched telephone network (PSTN) and join them into a Chime meeting. Also ensures that the From number belongs to the customer. To play welcome audio or implement an interactive voice response (IVR), use the
    /// CreateSipMediaApplicationCall action with the corresponding SIP media application ID.   This API is not available in a dedicated namespace.
    @Sendable
    @inlinable
    public func createMeetingDialOut(_ input: CreateMeetingDialOutRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMeetingDialOutResponse {
        try await self.client.execute(
            operation: "CreateMeetingDialOut", 
            path: "/meetings/{MeetingId}/dial-outs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Uses the join token and call metadata in a meeting request (From number, To number, and so forth) to initiate an outbound call to a public  switched telephone network (PSTN) and join them into a Chime meeting. Also ensures that the From number belongs to the customer. To play welcome audio or implement an interactive voice response (IVR), use the
    /// CreateSipMediaApplicationCall action with the corresponding SIP media application ID.   This API is not available in a dedicated namespace.
    ///
    /// Parameters:
    ///   - fromPhoneNumber: Phone number used as the caller ID when the remote party receives a call.
    ///   - joinToken: Token used by the Amazon Chime SDK attendee. Call the CreateAttendee action to get a join token.
    ///   - meetingId: The Amazon Chime SDK meeting ID.
    ///   - toPhoneNumber: Phone number called when inviting someone to a meeting.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMeetingDialOut(
        fromPhoneNumber: String,
        joinToken: String,
        meetingId: String,
        toPhoneNumber: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMeetingDialOutResponse {
        let input = CreateMeetingDialOutRequest(
            fromPhoneNumber: fromPhoneNumber, 
            joinToken: joinToken, 
            meetingId: meetingId, 
            toPhoneNumber: toPhoneNumber
        )
        return try await self.createMeetingDialOut(input, logger: logger)
    }

    /// Creates an order for phone numbers to be provisioned. For toll-free numbers, you cannot use the Amazon Chime Business Calling product type.  For numbers outside the U.S., you must use the Amazon Chime SIP Media Application Dial-In product type.
    @Sendable
    @inlinable
    public func createPhoneNumberOrder(_ input: CreatePhoneNumberOrderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePhoneNumberOrderResponse {
        try await self.client.execute(
            operation: "CreatePhoneNumberOrder", 
            path: "/phone-number-orders", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an order for phone numbers to be provisioned. For toll-free numbers, you cannot use the Amazon Chime Business Calling product type.  For numbers outside the U.S., you must use the Amazon Chime SIP Media Application Dial-In product type.
    ///
    /// Parameters:
    ///   - e164PhoneNumbers: List of phone numbers, in E.164 format.
    ///   - productType: The phone number product type.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPhoneNumberOrder(
        e164PhoneNumbers: [String],
        productType: PhoneNumberProductType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePhoneNumberOrderResponse {
        let input = CreatePhoneNumberOrderRequest(
            e164PhoneNumbers: e164PhoneNumbers, 
            productType: productType
        )
        return try await self.createPhoneNumberOrder(input, logger: logger)
    }

    /// Creates a chat room for the specified Amazon Chime Enterprise account.
    @Sendable
    @inlinable
    public func createRoom(_ input: CreateRoomRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRoomResponse {
        try await self.client.execute(
            operation: "CreateRoom", 
            path: "/accounts/{AccountId}/rooms", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a chat room for the specified Amazon Chime Enterprise account.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - clientRequestToken: The idempotency token for the request.
    ///   - name: The room name.
    ///   - logger: Logger use during operation
    @inlinable
    public func createRoom(
        accountId: String,
        clientRequestToken: String? = CreateRoomRequest.idempotencyToken(),
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRoomResponse {
        let input = CreateRoomRequest(
            accountId: accountId, 
            clientRequestToken: clientRequestToken, 
            name: name
        )
        return try await self.createRoom(input, logger: logger)
    }

    /// Adds a member to a chat room in an Amazon Chime Enterprise account. A member can be either a user or a bot. The member role designates whether the member is a chat room administrator or a general chat room member.
    @Sendable
    @inlinable
    public func createRoomMembership(_ input: CreateRoomMembershipRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRoomMembershipResponse {
        try await self.client.execute(
            operation: "CreateRoomMembership", 
            path: "/accounts/{AccountId}/rooms/{RoomId}/memberships", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds a member to a chat room in an Amazon Chime Enterprise account. A member can be either a user or a bot. The member role designates whether the member is a chat room administrator or a general chat room member.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - memberId: The Amazon Chime member ID (user ID or bot ID).
    ///   - role: The role of the member.
    ///   - roomId: The room ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func createRoomMembership(
        accountId: String,
        memberId: String,
        role: RoomMembershipRole? = nil,
        roomId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRoomMembershipResponse {
        let input = CreateRoomMembershipRequest(
            accountId: accountId, 
            memberId: memberId, 
            role: role, 
            roomId: roomId
        )
        return try await self.createRoomMembership(input, logger: logger)
    }

    /// Creates a user under the specified Amazon Chime account.
    @Sendable
    @inlinable
    public func createUser(_ input: CreateUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateUserResponse {
        try await self.client.execute(
            operation: "CreateUser", 
            path: "/accounts/{AccountId}/users?operation=create", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a user under the specified Amazon Chime account.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - email: The user's email address.
    ///   - username: The user name.
    ///   - userType: The user type.
    ///   - logger: Logger use during operation
    @inlinable
    public func createUser(
        accountId: String,
        email: String? = nil,
        username: String? = nil,
        userType: UserType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateUserResponse {
        let input = CreateUserRequest(
            accountId: accountId, 
            email: email, 
            username: username, 
            userType: userType
        )
        return try await self.createUser(input, logger: logger)
    }

    /// Deletes the specified Amazon Chime account. You must suspend all users before deleting Team account. You can use the BatchSuspendUser action to dodo. For EnterpriseLWA and EnterpriseAD accounts, you must release the claimed domains for your Amazon Chime account before deletion. As soon as you release the domain, all users under that account are suspended. Deleted accounts appear in your Disabled accounts list for 90 days. To restore deleted account from your Disabled accounts list, you must contact AWS Support. After 90 days, deleted accounts are permanently removed from your
    /// Disabled accounts list.
    @Sendable
    @inlinable
    public func deleteAccount(_ input: DeleteAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAccountResponse {
        try await self.client.execute(
            operation: "DeleteAccount", 
            path: "/accounts/{AccountId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified Amazon Chime account. You must suspend all users before deleting Team account. You can use the BatchSuspendUser action to dodo. For EnterpriseLWA and EnterpriseAD accounts, you must release the claimed domains for your Amazon Chime account before deletion. As soon as you release the domain, all users under that account are suspended. Deleted accounts appear in your Disabled accounts list for 90 days. To restore deleted account from your Disabled accounts list, you must contact AWS Support. After 90 days, deleted accounts are permanently removed from your
    /// Disabled accounts list.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAccount(
        accountId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAccountResponse {
        let input = DeleteAccountRequest(
            accountId: accountId
        )
        return try await self.deleteAccount(input, logger: logger)
    }

    /// Deletes the events configuration that allows a bot to receive outgoing events.
    @Sendable
    @inlinable
    public func deleteEventsConfiguration(_ input: DeleteEventsConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteEventsConfiguration", 
            path: "/accounts/{AccountId}/bots/{BotId}/events-configuration", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the events configuration that allows a bot to receive outgoing events.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - botId: The bot ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEventsConfiguration(
        accountId: String,
        botId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteEventsConfigurationRequest(
            accountId: accountId, 
            botId: botId
        )
        return try await self.deleteEventsConfiguration(input, logger: logger)
    }

    /// Moves the specified phone number into the Deletion queue. A phone number must be disassociated from any users or Amazon Chime Voice Connectors before it can be deleted. Deleted phone numbers remain in the
    /// Deletion queue
    /// for 7 days before they are deleted permanently.
    @Sendable
    @inlinable
    public func deletePhoneNumber(_ input: DeletePhoneNumberRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeletePhoneNumber", 
            path: "/phone-numbers/{PhoneNumberId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Moves the specified phone number into the Deletion queue. A phone number must be disassociated from any users or Amazon Chime Voice Connectors before it can be deleted. Deleted phone numbers remain in the
    /// Deletion queue
    /// for 7 days before they are deleted permanently.
    ///
    /// Parameters:
    ///   - phoneNumberId: The phone number ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePhoneNumber(
        phoneNumberId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeletePhoneNumberRequest(
            phoneNumberId: phoneNumberId
        )
        return try await self.deletePhoneNumber(input, logger: logger)
    }

    /// Deletes a chat room in an Amazon Chime Enterprise account.
    @Sendable
    @inlinable
    public func deleteRoom(_ input: DeleteRoomRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteRoom", 
            path: "/accounts/{AccountId}/rooms/{RoomId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a chat room in an Amazon Chime Enterprise account.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - roomId: The chat room ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRoom(
        accountId: String,
        roomId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteRoomRequest(
            accountId: accountId, 
            roomId: roomId
        )
        return try await self.deleteRoom(input, logger: logger)
    }

    /// Removes a member from a chat room in an Amazon Chime Enterprise account.
    @Sendable
    @inlinable
    public func deleteRoomMembership(_ input: DeleteRoomMembershipRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteRoomMembership", 
            path: "/accounts/{AccountId}/rooms/{RoomId}/memberships/{MemberId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a member from a chat room in an Amazon Chime Enterprise account.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - memberId: The member ID (user ID or bot ID).
    ///   - roomId: The room ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRoomMembership(
        accountId: String,
        memberId: String,
        roomId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteRoomMembershipRequest(
            accountId: accountId, 
            memberId: memberId, 
            roomId: roomId
        )
        return try await self.deleteRoomMembership(input, logger: logger)
    }

    /// Disassociates the primary provisioned phone number from the specified Amazon Chime user.
    @Sendable
    @inlinable
    public func disassociatePhoneNumberFromUser(_ input: DisassociatePhoneNumberFromUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociatePhoneNumberFromUserResponse {
        try await self.client.execute(
            operation: "DisassociatePhoneNumberFromUser", 
            path: "/accounts/{AccountId}/users/{UserId}?operation=disassociate-phone-number", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates the primary provisioned phone number from the specified Amazon Chime user.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - userId: The user ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociatePhoneNumberFromUser(
        accountId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociatePhoneNumberFromUserResponse {
        let input = DisassociatePhoneNumberFromUserRequest(
            accountId: accountId, 
            userId: userId
        )
        return try await self.disassociatePhoneNumberFromUser(input, logger: logger)
    }

    /// Disassociates the specified sign-in delegate groups from the specified Amazon Chime account.
    @Sendable
    @inlinable
    public func disassociateSigninDelegateGroupsFromAccount(_ input: DisassociateSigninDelegateGroupsFromAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateSigninDelegateGroupsFromAccountResponse {
        try await self.client.execute(
            operation: "DisassociateSigninDelegateGroupsFromAccount", 
            path: "/accounts/{AccountId}?operation=disassociate-signin-delegate-groups", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates the specified sign-in delegate groups from the specified Amazon Chime account.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - groupNames: The sign-in delegate group names.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateSigninDelegateGroupsFromAccount(
        accountId: String,
        groupNames: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateSigninDelegateGroupsFromAccountResponse {
        let input = DisassociateSigninDelegateGroupsFromAccountRequest(
            accountId: accountId, 
            groupNames: groupNames
        )
        return try await self.disassociateSigninDelegateGroupsFromAccount(input, logger: logger)
    }

    /// Retrieves details for the specified Amazon Chime account, such as account type and supported licenses.
    @Sendable
    @inlinable
    public func getAccount(_ input: GetAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAccountResponse {
        try await self.client.execute(
            operation: "GetAccount", 
            path: "/accounts/{AccountId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves details for the specified Amazon Chime account, such as account type and supported licenses.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAccount(
        accountId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAccountResponse {
        let input = GetAccountRequest(
            accountId: accountId
        )
        return try await self.getAccount(input, logger: logger)
    }

    /// Retrieves account settings for the specified Amazon Chime account ID, such as remote control and dialout settings. For more information about these settings, see  Use the Policies Page in the Amazon Chime Administration Guide.
    @Sendable
    @inlinable
    public func getAccountSettings(_ input: GetAccountSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAccountSettingsResponse {
        try await self.client.execute(
            operation: "GetAccountSettings", 
            path: "/accounts/{AccountId}/settings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves account settings for the specified Amazon Chime account ID, such as remote control and dialout settings. For more information about these settings, see  Use the Policies Page in the Amazon Chime Administration Guide.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAccountSettings(
        accountId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAccountSettingsResponse {
        let input = GetAccountSettingsRequest(
            accountId: accountId
        )
        return try await self.getAccountSettings(input, logger: logger)
    }

    /// Retrieves details for the specified bot, such as bot email address, bot type, status, and display name.
    @Sendable
    @inlinable
    public func getBot(_ input: GetBotRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetBotResponse {
        try await self.client.execute(
            operation: "GetBot", 
            path: "/accounts/{AccountId}/bots/{BotId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves details for the specified bot, such as bot email address, bot type, status, and display name.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - botId: The bot ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getBot(
        accountId: String,
        botId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetBotResponse {
        let input = GetBotRequest(
            accountId: accountId, 
            botId: botId
        )
        return try await self.getBot(input, logger: logger)
    }

    /// Gets details for an events configuration that allows a bot to receive outgoing events, such as an HTTPS endpoint or Lambda function ARN.
    @Sendable
    @inlinable
    public func getEventsConfiguration(_ input: GetEventsConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEventsConfigurationResponse {
        try await self.client.execute(
            operation: "GetEventsConfiguration", 
            path: "/accounts/{AccountId}/bots/{BotId}/events-configuration", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details for an events configuration that allows a bot to receive outgoing events, such as an HTTPS endpoint or Lambda function ARN.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - botId: The bot ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEventsConfiguration(
        accountId: String,
        botId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEventsConfigurationResponse {
        let input = GetEventsConfigurationRequest(
            accountId: accountId, 
            botId: botId
        )
        return try await self.getEventsConfiguration(input, logger: logger)
    }

    /// Retrieves global settings for the administrator's AWS account, such as Amazon Chime Business Calling and Amazon Chime Voice Connector settings.
    @Sendable
    @inlinable
    public func getGlobalSettings(logger: Logger = AWSClient.loggingDisabled) async throws -> GetGlobalSettingsResponse {
        try await self.client.execute(
            operation: "GetGlobalSettings", 
            path: "/settings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            logger: logger
        )
    }

    /// Retrieves details for the specified phone number ID, such as associations, capabilities, and product type.
    @Sendable
    @inlinable
    public func getPhoneNumber(_ input: GetPhoneNumberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPhoneNumberResponse {
        try await self.client.execute(
            operation: "GetPhoneNumber", 
            path: "/phone-numbers/{PhoneNumberId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves details for the specified phone number ID, such as associations, capabilities, and product type.
    ///
    /// Parameters:
    ///   - phoneNumberId: The phone number ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPhoneNumber(
        phoneNumberId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPhoneNumberResponse {
        let input = GetPhoneNumberRequest(
            phoneNumberId: phoneNumberId
        )
        return try await self.getPhoneNumber(input, logger: logger)
    }

    /// Retrieves details for the specified phone number order, such as the order creation timestamp, phone numbers in E.164 format, product type, and order status.
    @Sendable
    @inlinable
    public func getPhoneNumberOrder(_ input: GetPhoneNumberOrderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPhoneNumberOrderResponse {
        try await self.client.execute(
            operation: "GetPhoneNumberOrder", 
            path: "/phone-number-orders/{PhoneNumberOrderId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves details for the specified phone number order, such as the order creation timestamp, phone numbers in E.164 format, product type, and order status.
    ///
    /// Parameters:
    ///   - phoneNumberOrderId: The ID for the phone number order.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPhoneNumberOrder(
        phoneNumberOrderId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPhoneNumberOrderResponse {
        let input = GetPhoneNumberOrderRequest(
            phoneNumberOrderId: phoneNumberOrderId
        )
        return try await self.getPhoneNumberOrder(input, logger: logger)
    }

    /// Retrieves the phone number settings for the administrator's AWS account, such as the default outbound calling name.
    @Sendable
    @inlinable
    public func getPhoneNumberSettings(logger: Logger = AWSClient.loggingDisabled) async throws -> GetPhoneNumberSettingsResponse {
        try await self.client.execute(
            operation: "GetPhoneNumberSettings", 
            path: "/settings/phone-number", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            logger: logger
        )
    }

    /// Gets the retention settings for the specified Amazon Chime Enterprise account. For more information about retention settings, see
    /// Managing Chat Retention Policies in the Amazon Chime Administration Guide.
    @Sendable
    @inlinable
    public func getRetentionSettings(_ input: GetRetentionSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRetentionSettingsResponse {
        try await self.client.execute(
            operation: "GetRetentionSettings", 
            path: "/accounts/{AccountId}/retention-settings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the retention settings for the specified Amazon Chime Enterprise account. For more information about retention settings, see
    /// Managing Chat Retention Policies in the Amazon Chime Administration Guide.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRetentionSettings(
        accountId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRetentionSettingsResponse {
        let input = GetRetentionSettingsRequest(
            accountId: accountId
        )
        return try await self.getRetentionSettings(input, logger: logger)
    }

    /// Retrieves room details, such as the room name, for a room in an Amazon Chime Enterprise account.
    @Sendable
    @inlinable
    public func getRoom(_ input: GetRoomRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRoomResponse {
        try await self.client.execute(
            operation: "GetRoom", 
            path: "/accounts/{AccountId}/rooms/{RoomId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves room details, such as the room name, for a room in an Amazon Chime Enterprise account.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - roomId: The room ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRoom(
        accountId: String,
        roomId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRoomResponse {
        let input = GetRoomRequest(
            accountId: accountId, 
            roomId: roomId
        )
        return try await self.getRoom(input, logger: logger)
    }

    /// Retrieves details for the specified user ID, such as primary email address, license type,and personal meeting PIN.
    /// To retrieve user details with an email address instead of a user ID, use the
    /// ListUsers action, and then filter by email address.
    @Sendable
    @inlinable
    public func getUser(_ input: GetUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUserResponse {
        try await self.client.execute(
            operation: "GetUser", 
            path: "/accounts/{AccountId}/users/{UserId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves details for the specified user ID, such as primary email address, license type,and personal meeting PIN.
    /// To retrieve user details with an email address instead of a user ID, use the
    /// ListUsers action, and then filter by email address.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - userId: The user ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getUser(
        accountId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUserResponse {
        let input = GetUserRequest(
            accountId: accountId, 
            userId: userId
        )
        return try await self.getUser(input, logger: logger)
    }

    /// Retrieves settings for the specified user ID, such as any associated phone number settings.
    @Sendable
    @inlinable
    public func getUserSettings(_ input: GetUserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUserSettingsResponse {
        try await self.client.execute(
            operation: "GetUserSettings", 
            path: "/accounts/{AccountId}/users/{UserId}/settings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves settings for the specified user ID, such as any associated phone number settings.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - userId: The user ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func getUserSettings(
        accountId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUserSettingsResponse {
        let input = GetUserSettingsRequest(
            accountId: accountId, 
            userId: userId
        )
        return try await self.getUserSettings(input, logger: logger)
    }

    /// Sends email to a maximum of 50 users, inviting them to the specified Amazon Chime Team account. Only Team account types are currently supported for this action.
    @Sendable
    @inlinable
    public func inviteUsers(_ input: InviteUsersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> InviteUsersResponse {
        try await self.client.execute(
            operation: "InviteUsers", 
            path: "/accounts/{AccountId}/users?operation=add", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Sends email to a maximum of 50 users, inviting them to the specified Amazon Chime Team account. Only Team account types are currently supported for this action.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - userEmailList: The user email addresses to which to send the email invitation.
    ///   - userType: The user type.
    ///   - logger: Logger use during operation
    @inlinable
    public func inviteUsers(
        accountId: String,
        userEmailList: [String],
        userType: UserType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> InviteUsersResponse {
        let input = InviteUsersRequest(
            accountId: accountId, 
            userEmailList: userEmailList, 
            userType: userType
        )
        return try await self.inviteUsers(input, logger: logger)
    }

    /// Lists the Amazon Chime accounts under the administrator's AWS account. You can filter accounts by account name prefix. To find out which Amazon Chime account a user belongs to, you can filter by the user's email address, which returns one account result.
    @Sendable
    @inlinable
    public func listAccounts(_ input: ListAccountsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAccountsResponse {
        try await self.client.execute(
            operation: "ListAccounts", 
            path: "/accounts", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the Amazon Chime accounts under the administrator's AWS account. You can filter accounts by account name prefix. To find out which Amazon Chime account a user belongs to, you can filter by the user's email address, which returns one account result.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. Defaults to 100.
    ///   - name: Amazon Chime account name prefix with which to filter results.
    ///   - nextToken: The token to use to retrieve the next page of results.
    ///   - userEmail: User email address with which to filter results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAccounts(
        maxResults: Int? = nil,
        name: String? = nil,
        nextToken: String? = nil,
        userEmail: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAccountsResponse {
        let input = ListAccountsRequest(
            maxResults: maxResults, 
            name: name, 
            nextToken: nextToken, 
            userEmail: userEmail
        )
        return try await self.listAccounts(input, logger: logger)
    }

    /// Lists the bots associated with the administrator's Amazon Chime Enterprise account ID.
    @Sendable
    @inlinable
    public func listBots(_ input: ListBotsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListBotsResponse {
        try await self.client.execute(
            operation: "ListBots", 
            path: "/accounts/{AccountId}/bots", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the bots associated with the administrator's Amazon Chime Enterprise account ID.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - maxResults: The maximum number of results to return in a single call. The default is 10.
    ///   - nextToken: The token to use to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listBots(
        accountId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListBotsResponse {
        let input = ListBotsRequest(
            accountId: accountId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listBots(input, logger: logger)
    }

    /// Lists the phone number orders for the administrator's Amazon Chime account.
    @Sendable
    @inlinable
    public func listPhoneNumberOrders(_ input: ListPhoneNumberOrdersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPhoneNumberOrdersResponse {
        try await self.client.execute(
            operation: "ListPhoneNumberOrders", 
            path: "/phone-number-orders", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the phone number orders for the administrator's Amazon Chime account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - nextToken: The token to use to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPhoneNumberOrders(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPhoneNumberOrdersResponse {
        let input = ListPhoneNumberOrdersRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listPhoneNumberOrders(input, logger: logger)
    }

    /// Lists the phone numbers for the specified Amazon Chime account, Amazon Chime user, Amazon Chime Voice Connector, or Amazon Chime Voice Connector group.
    @Sendable
    @inlinable
    public func listPhoneNumbers(_ input: ListPhoneNumbersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPhoneNumbersResponse {
        try await self.client.execute(
            operation: "ListPhoneNumbers", 
            path: "/phone-numbers", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the phone numbers for the specified Amazon Chime account, Amazon Chime user, Amazon Chime Voice Connector, or Amazon Chime Voice Connector group.
    ///
    /// Parameters:
    ///   - filterName: The filter to use to limit the number of results.
    ///   - filterValue: The value to use for the filter.
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - nextToken: The token to use to retrieve the next page of results.
    ///   - productType: The phone number product type.
    ///   - status: The phone number status.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPhoneNumbers(
        filterName: PhoneNumberAssociationName? = nil,
        filterValue: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        productType: PhoneNumberProductType? = nil,
        status: PhoneNumberStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPhoneNumbersResponse {
        let input = ListPhoneNumbersRequest(
            filterName: filterName, 
            filterValue: filterValue, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            productType: productType, 
            status: status
        )
        return try await self.listPhoneNumbers(input, logger: logger)
    }

    /// Lists the membership details for the specified room in an Amazon Chime Enterprise account, such as the members' IDs, email addresses, and names.
    @Sendable
    @inlinable
    public func listRoomMemberships(_ input: ListRoomMembershipsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRoomMembershipsResponse {
        try await self.client.execute(
            operation: "ListRoomMemberships", 
            path: "/accounts/{AccountId}/rooms/{RoomId}/memberships", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the membership details for the specified room in an Amazon Chime Enterprise account, such as the members' IDs, email addresses, and names.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - nextToken: The token to use to retrieve the next page of results.
    ///   - roomId: The room ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRoomMemberships(
        accountId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        roomId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRoomMembershipsResponse {
        let input = ListRoomMembershipsRequest(
            accountId: accountId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            roomId: roomId
        )
        return try await self.listRoomMemberships(input, logger: logger)
    }

    /// Lists the room details for the specified Amazon Chime Enterprise account. Optionally, filter the results by a member ID (user ID or bot ID) to see a list of rooms that the member belongs to.
    @Sendable
    @inlinable
    public func listRooms(_ input: ListRoomsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRoomsResponse {
        try await self.client.execute(
            operation: "ListRooms", 
            path: "/accounts/{AccountId}/rooms", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the room details for the specified Amazon Chime Enterprise account. Optionally, filter the results by a member ID (user ID or bot ID) to see a list of rooms that the member belongs to.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - memberId: The member ID (user ID or bot ID).
    ///   - nextToken: The token to use to retrieve the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRooms(
        accountId: String,
        maxResults: Int? = nil,
        memberId: String? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRoomsResponse {
        let input = ListRoomsRequest(
            accountId: accountId, 
            maxResults: maxResults, 
            memberId: memberId, 
            nextToken: nextToken
        )
        return try await self.listRooms(input, logger: logger)
    }

    /// Lists supported phone number countries.
    @Sendable
    @inlinable
    public func listSupportedPhoneNumberCountries(_ input: ListSupportedPhoneNumberCountriesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSupportedPhoneNumberCountriesResponse {
        try await self.client.execute(
            operation: "ListSupportedPhoneNumberCountries", 
            path: "/phone-number-countries", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists supported phone number countries.
    ///
    /// Parameters:
    ///   - productType: The phone number product type.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSupportedPhoneNumberCountries(
        productType: PhoneNumberProductType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSupportedPhoneNumberCountriesResponse {
        let input = ListSupportedPhoneNumberCountriesRequest(
            productType: productType
        )
        return try await self.listSupportedPhoneNumberCountries(input, logger: logger)
    }

    /// Lists the users that belong to the specified Amazon Chime account. You can specify an email address to list only the user that the email address belongs to.
    @Sendable
    @inlinable
    public func listUsers(_ input: ListUsersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUsersResponse {
        try await self.client.execute(
            operation: "ListUsers", 
            path: "/accounts/{AccountId}/users", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the users that belong to the specified Amazon Chime account. You can specify an email address to list only the user that the email address belongs to.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - maxResults: The maximum number of results to return in a single call. Defaults to 100.
    ///   - nextToken: The token to use to retrieve the next page of results.
    ///   - userEmail: Optional. The user email address used to filter results. Maximum 1.
    ///   - userType: The user type.
    ///   - logger: Logger use during operation
    @inlinable
    public func listUsers(
        accountId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        userEmail: String? = nil,
        userType: UserType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUsersResponse {
        let input = ListUsersRequest(
            accountId: accountId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            userEmail: userEmail, 
            userType: userType
        )
        return try await self.listUsers(input, logger: logger)
    }

    /// Logs out the specified user from all of the devices they are currently logged into.
    @Sendable
    @inlinable
    public func logoutUser(_ input: LogoutUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> LogoutUserResponse {
        try await self.client.execute(
            operation: "LogoutUser", 
            path: "/accounts/{AccountId}/users/{UserId}?operation=logout", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Logs out the specified user from all of the devices they are currently logged into.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - userId: The user ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func logoutUser(
        accountId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> LogoutUserResponse {
        let input = LogoutUserRequest(
            accountId: accountId, 
            userId: userId
        )
        return try await self.logoutUser(input, logger: logger)
    }

    /// Creates an events configuration that allows a bot to receive outgoing events sent by Amazon Chime. Choose either an HTTPS endpoint or a Lambda function ARN. For more information, see Bot.
    @Sendable
    @inlinable
    public func putEventsConfiguration(_ input: PutEventsConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutEventsConfigurationResponse {
        try await self.client.execute(
            operation: "PutEventsConfiguration", 
            path: "/accounts/{AccountId}/bots/{BotId}/events-configuration", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an events configuration that allows a bot to receive outgoing events sent by Amazon Chime. Choose either an HTTPS endpoint or a Lambda function ARN. For more information, see Bot.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - botId: The bot ID.
    ///   - lambdaFunctionArn: Lambda function ARN that allows the bot to receive outgoing events.
    ///   - outboundEventsHTTPSEndpoint: HTTPS endpoint that allows the bot to receive outgoing events.
    ///   - logger: Logger use during operation
    @inlinable
    public func putEventsConfiguration(
        accountId: String,
        botId: String,
        lambdaFunctionArn: String? = nil,
        outboundEventsHTTPSEndpoint: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutEventsConfigurationResponse {
        let input = PutEventsConfigurationRequest(
            accountId: accountId, 
            botId: botId, 
            lambdaFunctionArn: lambdaFunctionArn, 
            outboundEventsHTTPSEndpoint: outboundEventsHTTPSEndpoint
        )
        return try await self.putEventsConfiguration(input, logger: logger)
    }

    /// Puts retention settings for the specified Amazon Chime Enterprise account. We recommend using AWS CloudTrail to monitor usage of this API for your account. For more information, see
    /// Logging Amazon Chime API Calls with AWS CloudTrail
    /// in the Amazon Chime Administration Guide.
    /// To turn off existing retention settings, remove the number of days from the corresponding
    /// RetentionDays
    /// field in the
    /// RetentionSettings
    /// object. For more information about retention settings, see
    /// Managing Chat Retention Policies
    /// in the Amazon Chime Administration Guide.
    @Sendable
    @inlinable
    public func putRetentionSettings(_ input: PutRetentionSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutRetentionSettingsResponse {
        try await self.client.execute(
            operation: "PutRetentionSettings", 
            path: "/accounts/{AccountId}/retention-settings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Puts retention settings for the specified Amazon Chime Enterprise account. We recommend using AWS CloudTrail to monitor usage of this API for your account. For more information, see
    /// Logging Amazon Chime API Calls with AWS CloudTrail
    /// in the Amazon Chime Administration Guide.
    /// To turn off existing retention settings, remove the number of days from the corresponding
    /// RetentionDays
    /// field in the
    /// RetentionSettings
    /// object. For more information about retention settings, see
    /// Managing Chat Retention Policies
    /// in the Amazon Chime Administration Guide.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - retentionSettings: The retention settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func putRetentionSettings(
        accountId: String,
        retentionSettings: RetentionSettings,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutRetentionSettingsResponse {
        let input = PutRetentionSettingsRequest(
            accountId: accountId, 
            retentionSettings: retentionSettings
        )
        return try await self.putRetentionSettings(input, logger: logger)
    }

    /// Redacts the specified message from the specified Amazon Chime conversation.
    @Sendable
    @inlinable
    public func redactConversationMessage(_ input: RedactConversationMessageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RedactConversationMessageResponse {
        try await self.client.execute(
            operation: "RedactConversationMessage", 
            path: "/accounts/{AccountId}/conversations/{ConversationId}/messages/{MessageId}?operation=redact", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Redacts the specified message from the specified Amazon Chime conversation.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - conversationId: The conversation ID.
    ///   - messageId: The message ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func redactConversationMessage(
        accountId: String,
        conversationId: String,
        messageId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RedactConversationMessageResponse {
        let input = RedactConversationMessageRequest(
            accountId: accountId, 
            conversationId: conversationId, 
            messageId: messageId
        )
        return try await self.redactConversationMessage(input, logger: logger)
    }

    /// Redacts the specified message from the specified Amazon Chime channel.
    @Sendable
    @inlinable
    public func redactRoomMessage(_ input: RedactRoomMessageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RedactRoomMessageResponse {
        try await self.client.execute(
            operation: "RedactRoomMessage", 
            path: "/accounts/{AccountId}/rooms/{RoomId}/messages/{MessageId}?operation=redact", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Redacts the specified message from the specified Amazon Chime channel.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - messageId: The message ID.
    ///   - roomId: The room ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func redactRoomMessage(
        accountId: String,
        messageId: String,
        roomId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RedactRoomMessageResponse {
        let input = RedactRoomMessageRequest(
            accountId: accountId, 
            messageId: messageId, 
            roomId: roomId
        )
        return try await self.redactRoomMessage(input, logger: logger)
    }

    /// Regenerates the security token for a bot.
    @Sendable
    @inlinable
    public func regenerateSecurityToken(_ input: RegenerateSecurityTokenRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RegenerateSecurityTokenResponse {
        try await self.client.execute(
            operation: "RegenerateSecurityToken", 
            path: "/accounts/{AccountId}/bots/{BotId}?operation=regenerate-security-token", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Regenerates the security token for a bot.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - botId: The bot ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func regenerateSecurityToken(
        accountId: String,
        botId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RegenerateSecurityTokenResponse {
        let input = RegenerateSecurityTokenRequest(
            accountId: accountId, 
            botId: botId
        )
        return try await self.regenerateSecurityToken(input, logger: logger)
    }

    /// Resets the personal meeting PIN for the specified user on an Amazon Chime account. Returns the User object with the updated personal meeting PIN.
    @Sendable
    @inlinable
    public func resetPersonalPIN(_ input: ResetPersonalPINRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ResetPersonalPINResponse {
        try await self.client.execute(
            operation: "ResetPersonalPIN", 
            path: "/accounts/{AccountId}/users/{UserId}?operation=reset-personal-pin", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Resets the personal meeting PIN for the specified user on an Amazon Chime account. Returns the User object with the updated personal meeting PIN.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - userId: The user ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func resetPersonalPIN(
        accountId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ResetPersonalPINResponse {
        let input = ResetPersonalPINRequest(
            accountId: accountId, 
            userId: userId
        )
        return try await self.resetPersonalPIN(input, logger: logger)
    }

    /// Moves a phone number from the Deletion queue back into the phone number Inventory.
    @Sendable
    @inlinable
    public func restorePhoneNumber(_ input: RestorePhoneNumberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RestorePhoneNumberResponse {
        try await self.client.execute(
            operation: "RestorePhoneNumber", 
            path: "/phone-numbers/{PhoneNumberId}?operation=restore", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Moves a phone number from the Deletion queue back into the phone number Inventory.
    ///
    /// Parameters:
    ///   - phoneNumberId: The phone number.
    ///   - logger: Logger use during operation
    @inlinable
    public func restorePhoneNumber(
        phoneNumberId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RestorePhoneNumberResponse {
        let input = RestorePhoneNumberRequest(
            phoneNumberId: phoneNumberId
        )
        return try await self.restorePhoneNumber(input, logger: logger)
    }

    /// Searches for phone numbers that can be ordered. For US numbers, provide at least one of the following search filters: AreaCode, City, State, or TollFreePrefix. If you provide City, you must also provide State. Numbers outside the US only support the PhoneNumberType filter, which you must use.
    @Sendable
    @inlinable
    public func searchAvailablePhoneNumbers(_ input: SearchAvailablePhoneNumbersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchAvailablePhoneNumbersResponse {
        try await self.client.execute(
            operation: "SearchAvailablePhoneNumbers", 
            path: "/search?type=phone-numbers", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for phone numbers that can be ordered. For US numbers, provide at least one of the following search filters: AreaCode, City, State, or TollFreePrefix. If you provide City, you must also provide State. Numbers outside the US only support the PhoneNumberType filter, which you must use.
    ///
    /// Parameters:
    ///   - areaCode: The area code used to filter results. Only applies to the US.
    ///   - city: The city used to filter results. Only applies to the US.
    ///   - country: The country used to filter results. Defaults to the US Format: ISO 3166-1 alpha-2.
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - nextToken: The token used to retrieve the next page of results.
    ///   - phoneNumberType: The phone number type used to filter results. Required for non-US numbers.
    ///   - state: The state used to filter results. Required only if you provide City. Only applies to the US.
    ///   - tollFreePrefix: The toll-free prefix that you use to filter results. Only applies to the US.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchAvailablePhoneNumbers(
        areaCode: String? = nil,
        city: String? = nil,
        country: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        phoneNumberType: PhoneNumberType? = nil,
        state: String? = nil,
        tollFreePrefix: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchAvailablePhoneNumbersResponse {
        let input = SearchAvailablePhoneNumbersRequest(
            areaCode: areaCode, 
            city: city, 
            country: country, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            phoneNumberType: phoneNumberType, 
            state: state, 
            tollFreePrefix: tollFreePrefix
        )
        return try await self.searchAvailablePhoneNumbers(input, logger: logger)
    }

    /// Updates account details for the specified Amazon Chime account. Currently, only account name and default license updates are supported for this action.
    @Sendable
    @inlinable
    public func updateAccount(_ input: UpdateAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAccountResponse {
        try await self.client.execute(
            operation: "UpdateAccount", 
            path: "/accounts/{AccountId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates account details for the specified Amazon Chime account. Currently, only account name and default license updates are supported for this action.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - defaultLicense: The default license applied when you add users to an Amazon Chime account.
    ///   - name: The new name for the specified Amazon Chime account.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAccount(
        accountId: String,
        defaultLicense: License? = nil,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAccountResponse {
        let input = UpdateAccountRequest(
            accountId: accountId, 
            defaultLicense: defaultLicense, 
            name: name
        )
        return try await self.updateAccount(input, logger: logger)
    }

    /// Updates the settings for the specified Amazon Chime account. You can update settings for remote control of shared screens, or for the dial-out option. For more information about these settings, see Use the Policies Page in the Amazon Chime Administration Guide.
    @Sendable
    @inlinable
    public func updateAccountSettings(_ input: UpdateAccountSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAccountSettingsResponse {
        try await self.client.execute(
            operation: "UpdateAccountSettings", 
            path: "/accounts/{AccountId}/settings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the settings for the specified Amazon Chime account. You can update settings for remote control of shared screens, or for the dial-out option. For more information about these settings, see Use the Policies Page in the Amazon Chime Administration Guide.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - accountSettings: The Amazon Chime account settings to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAccountSettings(
        accountId: String,
        accountSettings: AccountSettings,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAccountSettingsResponse {
        let input = UpdateAccountSettingsRequest(
            accountId: accountId, 
            accountSettings: accountSettings
        )
        return try await self.updateAccountSettings(input, logger: logger)
    }

    /// Updates the status of the specified bot, such as starting or stopping the bot from running in your Amazon Chime Enterprise account.
    @Sendable
    @inlinable
    public func updateBot(_ input: UpdateBotRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateBotResponse {
        try await self.client.execute(
            operation: "UpdateBot", 
            path: "/accounts/{AccountId}/bots/{BotId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the status of the specified bot, such as starting or stopping the bot from running in your Amazon Chime Enterprise account.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - botId: The bot ID.
    ///   - disabled: When true, stops the specified bot from running in your account.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateBot(
        accountId: String,
        botId: String,
        disabled: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateBotResponse {
        let input = UpdateBotRequest(
            accountId: accountId, 
            botId: botId, 
            disabled: disabled
        )
        return try await self.updateBot(input, logger: logger)
    }

    /// Updates global settings for the administrator's AWS account, such as Amazon Chime Business Calling and Amazon Chime Voice Connector settings.
    @Sendable
    @inlinable
    public func updateGlobalSettings(_ input: UpdateGlobalSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateGlobalSettings", 
            path: "/settings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates global settings for the administrator's AWS account, such as Amazon Chime Business Calling and Amazon Chime Voice Connector settings.
    ///
    /// Parameters:
    ///   - businessCalling: The Amazon Chime Business Calling settings.
    ///   - voiceConnector: The Amazon Chime Voice Connector settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateGlobalSettings(
        businessCalling: BusinessCallingSettings? = nil,
        voiceConnector: VoiceConnectorSettings? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateGlobalSettingsRequest(
            businessCalling: businessCalling, 
            voiceConnector: voiceConnector
        )
        return try await self.updateGlobalSettings(input, logger: logger)
    }

    /// Updates phone number details, such as product type or calling name, for the specified phone number ID. You can update one phone number detail at a time. For example, you can update either the product type or the calling name in one action. For toll-free numbers, you cannot use the Amazon Chime Business Calling product type. For numbers outside the U.S., you must use the Amazon Chime SIP Media Application Dial-In product type. Updates to outbound calling names can take 72 hours to complete. Pending updates to outbound calling names must be complete before you can request another update.
    @Sendable
    @inlinable
    public func updatePhoneNumber(_ input: UpdatePhoneNumberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePhoneNumberResponse {
        try await self.client.execute(
            operation: "UpdatePhoneNumber", 
            path: "/phone-numbers/{PhoneNumberId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates phone number details, such as product type or calling name, for the specified phone number ID. You can update one phone number detail at a time. For example, you can update either the product type or the calling name in one action. For toll-free numbers, you cannot use the Amazon Chime Business Calling product type. For numbers outside the U.S., you must use the Amazon Chime SIP Media Application Dial-In product type. Updates to outbound calling names can take 72 hours to complete. Pending updates to outbound calling names must be complete before you can request another update.
    ///
    /// Parameters:
    ///   - callingName: The outbound calling name associated with the phone number.
    ///   - phoneNumberId: The phone number ID.
    ///   - productType: The product type.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePhoneNumber(
        callingName: String? = nil,
        phoneNumberId: String,
        productType: PhoneNumberProductType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePhoneNumberResponse {
        let input = UpdatePhoneNumberRequest(
            callingName: callingName, 
            phoneNumberId: phoneNumberId, 
            productType: productType
        )
        return try await self.updatePhoneNumber(input, logger: logger)
    }

    /// Updates the phone number settings for the administrator's AWS account, such as the default outbound calling name. You can update the default outbound calling name once every seven days. Outbound calling names can take up to 72 hours to update.
    @Sendable
    @inlinable
    public func updatePhoneNumberSettings(_ input: UpdatePhoneNumberSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdatePhoneNumberSettings", 
            path: "/settings/phone-number", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the phone number settings for the administrator's AWS account, such as the default outbound calling name. You can update the default outbound calling name once every seven days. Outbound calling names can take up to 72 hours to update.
    ///
    /// Parameters:
    ///   - callingName: The default outbound calling name for the account.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePhoneNumberSettings(
        callingName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdatePhoneNumberSettingsRequest(
            callingName: callingName
        )
        return try await self.updatePhoneNumberSettings(input, logger: logger)
    }

    /// Updates room details, such as the room name, for a room in an Amazon Chime Enterprise account.
    @Sendable
    @inlinable
    public func updateRoom(_ input: UpdateRoomRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateRoomResponse {
        try await self.client.execute(
            operation: "UpdateRoom", 
            path: "/accounts/{AccountId}/rooms/{RoomId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates room details, such as the room name, for a room in an Amazon Chime Enterprise account.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - name: The room name.
    ///   - roomId: The room ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRoom(
        accountId: String,
        name: String? = nil,
        roomId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateRoomResponse {
        let input = UpdateRoomRequest(
            accountId: accountId, 
            name: name, 
            roomId: roomId
        )
        return try await self.updateRoom(input, logger: logger)
    }

    /// Updates room membership details, such as the member role, for a room in an Amazon Chime Enterprise account. The member role designates whether the member is a chat room administrator or a general chat room member. The member role can be updated only for user IDs.
    @Sendable
    @inlinable
    public func updateRoomMembership(_ input: UpdateRoomMembershipRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateRoomMembershipResponse {
        try await self.client.execute(
            operation: "UpdateRoomMembership", 
            path: "/accounts/{AccountId}/rooms/{RoomId}/memberships/{MemberId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates room membership details, such as the member role, for a room in an Amazon Chime Enterprise account. The member role designates whether the member is a chat room administrator or a general chat room member. The member role can be updated only for user IDs.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - memberId: The member ID.
    ///   - role: The role of the member.
    ///   - roomId: The room ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRoomMembership(
        accountId: String,
        memberId: String,
        role: RoomMembershipRole? = nil,
        roomId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateRoomMembershipResponse {
        let input = UpdateRoomMembershipRequest(
            accountId: accountId, 
            memberId: memberId, 
            role: role, 
            roomId: roomId
        )
        return try await self.updateRoomMembership(input, logger: logger)
    }

    /// Updates user details for a specified user ID. Currently, only LicenseType updates are supported for this action.
    @Sendable
    @inlinable
    public func updateUser(_ input: UpdateUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateUserResponse {
        try await self.client.execute(
            operation: "UpdateUser", 
            path: "/accounts/{AccountId}/users/{UserId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates user details for a specified user ID. Currently, only LicenseType updates are supported for this action.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - alexaForBusinessMetadata: The Alexa for Business metadata.
    ///   - licenseType: The user license type to update. This must be a supported license type for the Amazon Chime account that the user belongs to.
    ///   - userId: The user ID.
    ///   - userType: The user type.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUser(
        accountId: String,
        alexaForBusinessMetadata: AlexaForBusinessMetadata? = nil,
        licenseType: License? = nil,
        userId: String,
        userType: UserType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateUserResponse {
        let input = UpdateUserRequest(
            accountId: accountId, 
            alexaForBusinessMetadata: alexaForBusinessMetadata, 
            licenseType: licenseType, 
            userId: userId, 
            userType: userType
        )
        return try await self.updateUser(input, logger: logger)
    }

    /// Updates the settings for the specified user, such as phone number settings.
    @Sendable
    @inlinable
    public func updateUserSettings(_ input: UpdateUserSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateUserSettings", 
            path: "/accounts/{AccountId}/users/{UserId}/settings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the settings for the specified user, such as phone number settings.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - userId: The user ID.
    ///   - userSettings: The user settings to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUserSettings(
        accountId: String,
        userId: String,
        userSettings: UserSettings,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateUserSettingsRequest(
            accountId: accountId, 
            userId: userId, 
            userSettings: userSettings
        )
        return try await self.updateUserSettings(input, logger: logger)
    }
}

extension Chime {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Chime, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Chime {
    /// Return PaginatorSequence for operation ``listAccounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccountsPaginator(
        _ input: ListAccountsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAccountsRequest, ListAccountsResponse> {
        return .init(
            input: input,
            command: self.listAccounts,
            inputKey: \ListAccountsRequest.nextToken,
            outputKey: \ListAccountsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAccounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. Defaults to 100.
    ///   - name: Amazon Chime account name prefix with which to filter results.
    ///   - userEmail: User email address with which to filter results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccountsPaginator(
        maxResults: Int? = nil,
        name: String? = nil,
        userEmail: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAccountsRequest, ListAccountsResponse> {
        let input = ListAccountsRequest(
            maxResults: maxResults, 
            name: name, 
            userEmail: userEmail
        )
        return self.listAccountsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listBots(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listBotsPaginator(
        _ input: ListBotsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListBotsRequest, ListBotsResponse> {
        return .init(
            input: input,
            command: self.listBots,
            inputKey: \ListBotsRequest.nextToken,
            outputKey: \ListBotsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listBots(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - maxResults: The maximum number of results to return in a single call. The default is 10.
    ///   - logger: Logger used for logging
    @inlinable
    public func listBotsPaginator(
        accountId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListBotsRequest, ListBotsResponse> {
        let input = ListBotsRequest(
            accountId: accountId, 
            maxResults: maxResults
        )
        return self.listBotsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPhoneNumberOrders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPhoneNumberOrdersPaginator(
        _ input: ListPhoneNumberOrdersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPhoneNumberOrdersRequest, ListPhoneNumberOrdersResponse> {
        return .init(
            input: input,
            command: self.listPhoneNumberOrders,
            inputKey: \ListPhoneNumberOrdersRequest.nextToken,
            outputKey: \ListPhoneNumberOrdersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPhoneNumberOrders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPhoneNumberOrdersPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPhoneNumberOrdersRequest, ListPhoneNumberOrdersResponse> {
        let input = ListPhoneNumberOrdersRequest(
            maxResults: maxResults
        )
        return self.listPhoneNumberOrdersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPhoneNumbers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPhoneNumbersPaginator(
        _ input: ListPhoneNumbersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPhoneNumbersRequest, ListPhoneNumbersResponse> {
        return .init(
            input: input,
            command: self.listPhoneNumbers,
            inputKey: \ListPhoneNumbersRequest.nextToken,
            outputKey: \ListPhoneNumbersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPhoneNumbers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterName: The filter to use to limit the number of results.
    ///   - filterValue: The value to use for the filter.
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - productType: The phone number product type.
    ///   - status: The phone number status.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPhoneNumbersPaginator(
        filterName: PhoneNumberAssociationName? = nil,
        filterValue: String? = nil,
        maxResults: Int? = nil,
        productType: PhoneNumberProductType? = nil,
        status: PhoneNumberStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPhoneNumbersRequest, ListPhoneNumbersResponse> {
        let input = ListPhoneNumbersRequest(
            filterName: filterName, 
            filterValue: filterValue, 
            maxResults: maxResults, 
            productType: productType, 
            status: status
        )
        return self.listPhoneNumbersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRoomMemberships(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRoomMembershipsPaginator(
        _ input: ListRoomMembershipsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRoomMembershipsRequest, ListRoomMembershipsResponse> {
        return .init(
            input: input,
            command: self.listRoomMemberships,
            inputKey: \ListRoomMembershipsRequest.nextToken,
            outputKey: \ListRoomMembershipsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRoomMemberships(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - roomId: The room ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRoomMembershipsPaginator(
        accountId: String,
        maxResults: Int? = nil,
        roomId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRoomMembershipsRequest, ListRoomMembershipsResponse> {
        let input = ListRoomMembershipsRequest(
            accountId: accountId, 
            maxResults: maxResults, 
            roomId: roomId
        )
        return self.listRoomMembershipsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRooms(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRoomsPaginator(
        _ input: ListRoomsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRoomsRequest, ListRoomsResponse> {
        return .init(
            input: input,
            command: self.listRooms,
            inputKey: \ListRoomsRequest.nextToken,
            outputKey: \ListRoomsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRooms(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - memberId: The member ID (user ID or bot ID).
    ///   - logger: Logger used for logging
    @inlinable
    public func listRoomsPaginator(
        accountId: String,
        maxResults: Int? = nil,
        memberId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRoomsRequest, ListRoomsResponse> {
        let input = ListRoomsRequest(
            accountId: accountId, 
            maxResults: maxResults, 
            memberId: memberId
        )
        return self.listRoomsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listUsers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listUsersPaginator(
        _ input: ListUsersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListUsersRequest, ListUsersResponse> {
        return .init(
            input: input,
            command: self.listUsers,
            inputKey: \ListUsersRequest.nextToken,
            outputKey: \ListUsersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listUsers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: The Amazon Chime account ID.
    ///   - maxResults: The maximum number of results to return in a single call. Defaults to 100.
    ///   - userEmail: Optional. The user email address used to filter results. Maximum 1.
    ///   - userType: The user type.
    ///   - logger: Logger used for logging
    @inlinable
    public func listUsersPaginator(
        accountId: String,
        maxResults: Int? = nil,
        userEmail: String? = nil,
        userType: UserType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListUsersRequest, ListUsersResponse> {
        let input = ListUsersRequest(
            accountId: accountId, 
            maxResults: maxResults, 
            userEmail: userEmail, 
            userType: userType
        )
        return self.listUsersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchAvailablePhoneNumbers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchAvailablePhoneNumbersPaginator(
        _ input: SearchAvailablePhoneNumbersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchAvailablePhoneNumbersRequest, SearchAvailablePhoneNumbersResponse> {
        return .init(
            input: input,
            command: self.searchAvailablePhoneNumbers,
            inputKey: \SearchAvailablePhoneNumbersRequest.nextToken,
            outputKey: \SearchAvailablePhoneNumbersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchAvailablePhoneNumbers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - areaCode: The area code used to filter results. Only applies to the US.
    ///   - city: The city used to filter results. Only applies to the US.
    ///   - country: The country used to filter results. Defaults to the US Format: ISO 3166-1 alpha-2.
    ///   - maxResults: The maximum number of results to return in a single call.
    ///   - phoneNumberType: The phone number type used to filter results. Required for non-US numbers.
    ///   - state: The state used to filter results. Required only if you provide City. Only applies to the US.
    ///   - tollFreePrefix: The toll-free prefix that you use to filter results. Only applies to the US.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchAvailablePhoneNumbersPaginator(
        areaCode: String? = nil,
        city: String? = nil,
        country: String? = nil,
        maxResults: Int? = nil,
        phoneNumberType: PhoneNumberType? = nil,
        state: String? = nil,
        tollFreePrefix: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchAvailablePhoneNumbersRequest, SearchAvailablePhoneNumbersResponse> {
        let input = SearchAvailablePhoneNumbersRequest(
            areaCode: areaCode, 
            city: city, 
            country: country, 
            maxResults: maxResults, 
            phoneNumberType: phoneNumberType, 
            state: state, 
            tollFreePrefix: tollFreePrefix
        )
        return self.searchAvailablePhoneNumbersPaginator(input, logger: logger)
    }
}

extension Chime.ListAccountsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chime.ListAccountsRequest {
        return .init(
            maxResults: self.maxResults,
            name: self.name,
            nextToken: token,
            userEmail: self.userEmail
        )
    }
}

extension Chime.ListBotsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chime.ListBotsRequest {
        return .init(
            accountId: self.accountId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Chime.ListPhoneNumberOrdersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chime.ListPhoneNumberOrdersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Chime.ListPhoneNumbersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chime.ListPhoneNumbersRequest {
        return .init(
            filterName: self.filterName,
            filterValue: self.filterValue,
            maxResults: self.maxResults,
            nextToken: token,
            productType: self.productType,
            status: self.status
        )
    }
}

extension Chime.ListRoomMembershipsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chime.ListRoomMembershipsRequest {
        return .init(
            accountId: self.accountId,
            maxResults: self.maxResults,
            nextToken: token,
            roomId: self.roomId
        )
    }
}

extension Chime.ListRoomsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chime.ListRoomsRequest {
        return .init(
            accountId: self.accountId,
            maxResults: self.maxResults,
            memberId: self.memberId,
            nextToken: token
        )
    }
}

extension Chime.ListUsersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chime.ListUsersRequest {
        return .init(
            accountId: self.accountId,
            maxResults: self.maxResults,
            nextToken: token,
            userEmail: self.userEmail,
            userType: self.userType
        )
    }
}

extension Chime.SearchAvailablePhoneNumbersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Chime.SearchAvailablePhoneNumbersRequest {
        return .init(
            areaCode: self.areaCode,
            city: self.city,
            country: self.country,
            maxResults: self.maxResults,
            nextToken: token,
            phoneNumberType: self.phoneNumberType,
            state: self.state,
            tollFreePrefix: self.tollFreePrefix
        )
    }
}
